import axios from 'axios'

// API前缀
const API_PREFIX = '/api'

// 创建axios实例
const api = axios.create({
  baseURL: '',
  timeout: 15000,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 输出调试信息
console.log('API配置:', {
  baseURL: api.defaults.baseURL,
  timeout: api.defaults.timeout,
  apiPrefix: API_PREFIX
})

// 添加重试逻辑
const MAX_RETRIES = 3
const RETRY_DELAY = 2000 // 2秒

// 修改请求拦截器
api.interceptors.request.use(
  async config => {
    // 直接返回配置，跳过IP检查
    return config;
  },
  error => {
    console.error('请求拦截器错误:', error);
    return Promise.reject(error);
  }
);

// 修改响应拦截器，移除IP相关的错误处理
api.interceptors.response.use(
  response => response,
  async error => {
    // 其他错误处理
    if (error.friendlyMessage) {
      error.message = error.friendlyMessage;
    }
    return Promise.reject(error);
  }
);

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 在发送请求之前做些什么
    const fullUrl = (config.baseURL || '') + config.url
    console.log(`API请求: ${config.method?.toUpperCase()} ${fullUrl}`, config.params || {})
    
    // 添加请求ID，用于取消请求
    config.requestId = config.url + (config.params ? JSON.stringify(config.params) : '')
    
    // 添加重试计数
    config.retryCount = config.retryCount || 0
    
    return config
  },
  error => {
    // 对请求错误做些什么
    console.error('API请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 对响应数据做点什么
    console.log(`API响应: ${response.status} ${response.config.url}`)
    
    // 检查响应数据是否有效
    if (!response.data) {
      console.warn('API响应数据为空:', response.config.url)
    }
    
    return response
  },
  async error => {
    const originalRequest = error.config
    
    if (!originalRequest) {
      console.error('API错误: 没有原始请求配置', error)
      return Promise.reject(error)
    }
    
    console.error(`API错误: ${originalRequest.method?.toUpperCase()} ${originalRequest.url}`, error.message)
    
    // 如果请求失败并且没有超过最大重试次数，则重试
    if (error.response && error.response.status >= 500 && originalRequest && originalRequest.retryCount < MAX_RETRIES) {
      originalRequest.retryCount++
      console.log(`重试请求 (${originalRequest.retryCount}/${MAX_RETRIES}): ${originalRequest.url}`)
      
      // 等待一段时间后重试
      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY))
      return api(originalRequest)
    }
    
    // 格式化错误消息
    let errorMessage = '请求失败'
    
    if (error.response) {
      // 服务器返回了错误状态码
      const status = error.response.status
      const data = error.response.data
      
      switch (status) {
        case 400:
          errorMessage = `请求错误: ${data.error || '参数无效'}`
          break
        case 401:
          errorMessage = '未授权，请登录'
          break
        case 403:
          errorMessage = '禁止访问'
          break
        case 404:
          errorMessage = `未找到: ${originalRequest.url}`
          break
        case 500:
          errorMessage = `服务器错误: ${data.error || '内部错误'}`
          break
        default:
          errorMessage = `请求失败: ${status} ${data.error || ''}`
      }
    } else if (error.request) {
      // 请求已发送但没有收到响应
      if (error.code === 'ECONNABORTED') {
        errorMessage = '请求超时，请稍后重试'
      } else {
        errorMessage = '网络错误，请检查您的网络连接'
      }
    } else {
      // 请求设置时发生错误
      errorMessage = `请求配置错误: ${error.message}`
    }
    
    error.friendlyMessage = errorMessage
    return Promise.reject(error)
  }
)

// 请求取消控制器
const controllers = new Map()

// 安全地包装API调用
function safeApiCall(apiFunc) {
  return async (...args) => {
    try {
      const response = await apiFunc(...args);
      return response;
    } catch (error) {
      if (axios.isCancel(error)) {
        console.log('请求已取消:', error.message);
        throw new Error('请求已取消');
      }

      // 处理IP授权错误
      if (error.isIPAuthError) {
        console.error('IP授权错误:', error.friendlyMessage);
        // 这里可以添加全局的错误处理，比如显示提示框
        throw new Error(error.friendlyMessage);
      }

      console.error(`API调用失败:`, error);
      throw new Error(error.friendlyMessage || error.message || '请求失败');
    }
  }
}

// 模型相关API
const apiService = {
  // 模型管理
  getModels: safeApiCall(async () => {
    console.log('调用 getModels API')
    try {
      const response = await api.get(`${API_PREFIX}/models`)
      
      // 检查响应
      if (!response) {
        console.error('getModels: 响应为空')
        throw new Error('API响应为空')
      }
      
      if (!response.data) {
        console.error('getModels: 响应数据为空', response)
        throw new Error('API响应数据为空')
      }
      
      // 确保返回的是数组
      if (!Array.isArray(response.data)) {
        console.error('getModels: 响应数据不是数组', response.data)
        // 尝试找到数据中的数组属性
        let dataArray = null
        
        // 如果响应是对象，尝试找到其中的数组属性
        if (typeof response.data === 'object') {
          for (const key in response.data) {
            if (Array.isArray(response.data[key])) {
              console.log(`getModels: 在响应的 ${key} 属性中找到数组`)
              dataArray = response.data[key]
              break
            }
          }
        }
        
        // 如果找到了数组，使用它；否则返回空数组
        response.data = dataArray || []
      }
      
      // 验证每个模型对象
      if (Array.isArray(response.data)) {
        response.data = response.data.map(model => {
          if (!model) return null
          
          // 确保每个模型至少有基本属性
          return {
            id: model.id || `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
            name: model.name || `unnamed_${Date.now()}`,
            displayName: model.displayName || model.name || '未命名模型',
            fields: Array.isArray(model.fields) ? model.fields : [],
            ...model
          }
        }).filter(model => model !== null)
      }
      
      console.log(`getModels: 成功获取 ${response.data.length} 个模型`)
      return response
    } catch (error) {
      console.error('getModels API 错误:', error)
      // 返回一个有效的响应，避免后续处理出错
      return { data: [] }
    }
  }),
  getModel: safeApiCall(async (id) => {
    if (!id) {
      console.error('getModel: ID为空')
      throw new Error('模型ID不能为空')
    }
    
    console.log(`调用 getModel API, ID: ${id}`)
    
    try {
      const response = await api.get(`${API_PREFIX}/models/${id}`)
      
      if (!response || !response.data) {
        console.error(`getModel: 获取ID为 ${id} 的模型失败，响应无效`, response)
        throw new Error('API返回的数据无效')
      }
      
      // 确保模型对象有必要的属性
      if (!response.data.name) {
        console.warn(`getModel: 模型缺少name属性`, response.data)
        response.data.name = `model_${id}`
      }
      
      console.log(`getModel: 成功获取模型 ${response.data.name}`)
      return response
    } catch (error) {
      console.error(`getModel API 错误, ID: ${id}:`, error)
      throw error
    }
  }),
  createModel: safeApiCall((data) => api.post(`${API_PREFIX}/models`, data)),
  updateModel: safeApiCall((id, data) => api.put(`${API_PREFIX}/models/${id}`, data)),
  deleteModel: safeApiCall((id) => api.delete(`${API_PREFIX}/models/${id}`)),
  
  // 数据管理
  getData: safeApiCall(async (modelName, params = {}) => {
    if (!modelName) {
      throw new Error('模型名称不能为空')
    }
    
    console.log(`调用 getData API, 模型: ${modelName}, 参数:`, params)
    
    try {
      const response = await api.get(`${API_PREFIX}/data/${modelName}`, { params })
      
      // 检查响应
      if (!response) {
        console.error(`getData: 响应为空, 模型: ${modelName}`)
        throw new Error('API响应为空')
      }
      
      if (!response.data) {
        console.error(`getData: 响应数据为空, 模型: ${modelName}`, response)
        throw new Error('API响应数据为空')
      }
      
      // 特殊处理 items 字段
      if (response.data.items && typeof response.data.items === 'object' && !Array.isArray(response.data.items) && response.data.items.id) {
        console.log(`getData: 发现items是单个对象，修正响应结构`)
        
        // 创建一个新的响应对象，将items作为数组返回
        const fixedResponse = {
          ...response,
          data: {
            ...response.data,
            items: [response.data.items]
          }
        }
        
        return fixedResponse
      }
      
      return response
    } catch (error) {
      console.error(`getData API 错误, 模型: ${modelName}:`, error)
      throw error
    }
  }),
  getRecord: safeApiCall((modelName, id) => {
    if (!modelName || !id) {
      throw new Error('模型名称和ID不能为空')
    }
    return api.get(`${API_PREFIX}/data/${modelName}/${id}`)
  }),
  createRecord: safeApiCall(async (modelName, data) => {
    if (!modelName) {
      throw new Error('模型名称不能为空')
    }
    
    console.log(`调用 createRecord API, 模型: ${modelName}, 数据:`, data)
    
    // 处理数据，确保所有值都是字符串
    const processedData = {}
    for (const key in data) {
      if (data[key] !== null && data[key] !== undefined) {
        processedData[key] = String(data[key])
      } else {
        processedData[key] = ''
      }
    }
    
    console.log(`处理后的数据:`, processedData)
    
    try {
      // 尝试使用fetch API代替axios
      const fetchResponse = await fetch(`${API_PREFIX}/data/${modelName}`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(processedData)
      })
      
      if (!fetchResponse.ok) {
        const errorText = await fetchResponse.text()
        console.error(`创建记录失败: ${fetchResponse.status} ${fetchResponse.statusText}`, errorText)
        throw new Error(`创建记录失败: ${fetchResponse.status} ${fetchResponse.statusText}`)
      }
      
      const responseData = await fetchResponse.json()
      console.log(`创建记录成功:`, responseData)
      
      return { data: responseData }
    } catch (error) {
      console.error(`createRecord API 错误, 模型: ${modelName}:`, error)
      throw error
    }
  }),
  updateRecord: safeApiCall(async (modelName, id, data) => {
    if (!modelName || !id) {
      throw new Error('模型名称和ID不能为空')
    }
    
    console.log(`调用 updateRecord API, 模型: ${modelName}, ID: ${id}, 数据:`, data)
    
    // 处理数据，确保所有值都是字符串
    const processedData = {}
    for (const key in data) {
      if (data[key] !== null && data[key] !== undefined) {
        processedData[key] = String(data[key])
      } else {
        processedData[key] = ''
      }
    }
    
    console.log(`处理后的数据:`, processedData)
    
    try {
      // 尝试使用fetch API代替axios
      const fetchResponse = await fetch(`${API_PREFIX}/data/${modelName}/${id}`, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(processedData)
      })
      
      if (!fetchResponse.ok) {
        const errorText = await fetchResponse.text()
        console.error(`更新记录失败: ${fetchResponse.status} ${fetchResponse.statusText}`, errorText)
        throw new Error(`更新记录失败: ${fetchResponse.status} ${fetchResponse.statusText}`)
      }
      
      const responseData = await fetchResponse.json()
      console.log(`更新记录成功:`, responseData)
      
      return { data: responseData }
    } catch (error) {
      console.error(`updateRecord API 错误, 模型: ${modelName}:`, error)
      throw error
    }
  }),
  deleteRecord: safeApiCall((modelName, id) => {
    if (!modelName || !id) {
      throw new Error('模型名称和ID不能为空')
    }
    return api.delete(`${API_PREFIX}/data/${modelName}/${id}`)
  }),
  
  // 系统设置
  getSettings: safeApiCall(() => api.get(`${API_PREFIX}/settings`)),
  updateSettings: safeApiCall((data) => api.post(`${API_PREFIX}/settings`, data)),
  testConnection: safeApiCall((config) => api.post(`${API_PREFIX}/settings/test-connection`, config)),
  
  // 系统状态
  getStatus: safeApiCall(() => api.get(`${API_PREFIX}/status`)),
  
  // 测试API连接
  ping: safeApiCall(() => api.get(`${API_PREFIX}/ping`)),
  
  // 取消所有请求
  cancelAllRequests: (message = '用户取消') => {
    controllers.forEach(controller => {
      controller.abort(message)
    })
    controllers.clear()
  },

  // IP授权管理相关API
  auth: {
    // 获取所有授权IP
    getAuthorizedIPs: safeApiCall(async () => {
      console.log('获取授权IP列表');
      const response = await api.get(`${API_PREFIX}/auth/ips`);
      return response;
    }),

    // 添加授权IP
    addAuthorizedIP: safeApiCall(async (data) => {
      console.log('添加授权IP:', data);
      const response = await api.post(`${API_PREFIX}/auth/ips`, data);
      return response;
    }),

    // 更新授权IP
    updateAuthorizedIP: safeApiCall(async (id, data) => {
      console.log('更新授权IP状态:', id, data);
      const response = await api.put(`${API_PREFIX}/auth/ips/${id}`, data);
      return response;
    }),

    // 删除授权IP
    deleteAuthorizedIP: safeApiCall(async (id) => {
      console.log('删除授权IP:', id);
      const response = await api.delete(`${API_PREFIX}/auth/ips/${id}`);
      return response;
    }),

    // 检查当前IP状态
    checkCurrentIP: safeApiCall(async () => {
      console.log('检查当前IP状态');
      try {
        const response = await api.get(`${API_PREFIX}/auth/check-status`);
        console.log('当前IP状态:', response.data);
        return response;
      } catch (error) {
        if (error.isIPAuthError) {
          console.warn('IP授权检查:', error.friendlyMessage);
        } else {
          console.error('IP状态检查失败:', error);
        }
        throw error;
      }
    })
  },

  // 请求拦截器中添加IP授权状态检查
  setupIPAuthInterceptor() {
    api.interceptors.response.use(
      response => response,
      async error => {
        if (error.response?.status === 403 && error.response?.data?.code === 'UNAUTHORIZED_IP') {
          // 触发未授权IP的错误处理
          console.error('IP未授权访问:', error.response.data);
          
          // 可以在这里添加全局的未授权IP处理逻辑
          // 例如：显示一个全局提示，或者跳转到IP授权申请页面
          
          // 重新抛出一个更友好的错误
          throw new Error('您的IP地址未获得授权，请联系管理员');
        }
        return Promise.reject(error);
      }
    );
  }
}

// 初始化IP授权拦截器
apiService.setupIPAuthInterceptor();

// 在应用启动时检查当前IP状态
apiService.auth.checkCurrentIP()
  .then(response => {
    console.log('当前IP状态:', response.data);
    if (!response.data.status.isAuthorized) {
      console.warn('当前IP未授权:', response.data.message);
    }
  })
  .catch(error => {
    console.error('检查IP状态失败:', error);
  });

// 测试API连接
apiService.ping()
  .then(response => {
    console.log('API连接测试成功:', response.data)
  })
  .catch(error => {
    console.error('API连接测试失败:', error.message)
  })

// 移除初始化IP检查
function initializeIPCheck() {
  // 空函数，不再执行IP检查
  console.log('IP检查已禁用');
}

export default apiService 